package net.easoftware.code.mb;

import com.easoftware.code.beans.graphics.Donut;
import com.easoftware.code.beans.graphics.HistogramPoint;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Serializable;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import javax.enterprise.context.SessionScoped;
import javax.inject.Inject;
import javax.inject.Named;
import net.easoftware.code.beans.*;
import net.easoftware.code.beans.facade.Cliente8020Fc;
import net.easoftware.code.beans.facade.ClienteProvisionCuentas;
import net.easoftware.code.beans.facade.LineaNegocio;
import net.easoftware.code.beans.facade.MICredRubro;
import net.easoftware.code.beans.facade.UnidadNegocio;
import net.easoftware.code.beans.facade.UsuarioFc;
import net.easoftware.code.dao.CatalogosDao;
import net.easoftware.code.dao.ReporteDao;
import net.easoftware.code.error.EaError;
import net.easoftware.code.util.ExcelProccesor;
import net.easoftware.code.util.Tools;
import org.apache.log4j.Logger;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.StreamedContent;

/**
 *
 * @author ediaz
 */
@SessionScoped
@Named
public class MbSummary implements Serializable {

    private static final Logger log = Logger.getLogger(MbSummary.class.getName());
    @Inject
    private ReporteDao reporteDao;
    @Inject
    private GraphicsUnoPetrol graficasUnopetrol;
    @Inject
    CatalogosDao catalogosDao;
    @Inject
    MbIndex mbIndex;
    @Inject
    UsuarioFc usuarioApp;
    private List<UnidadNegocio> unidadesDeNegocio;
    private List<LineaNegocio> lineasDeNegocios;
    private List<Columna> columnasRepVentas;
    private List<List<Columna>> filasRepVentas;
    private List<List<Columna>> filasRepVentasG1;
    private List<List<Columna>> filasRepVentasG2;
    private List<Columna> columnasPaises;
    private List<List<Columna>> filasPaises;
    private List<List<Columna>> filasPaisesG1;
    private List<List<Columna>> filasPaisesG2;
    private List<List<Columna>> filasPaisesG3;
    private List<List<Columna>> filasPaisesG4;
    private List<Columna> columnas;
    private List<List<Columna>> filas;
    private List<List<Columna>> filasG1;
    private List<List<Columna>> filasG2;
    private List<List<Columna>> filasG3;
    private List<List<Columna>> filasG4;
    private List<Columna> columnasDet;
    private List<List<Columna>> filasDet;
    private List<List<Columna>> filasDetG1;
    private List<List<Columna>> filasDetG2;
    private List<List<Columna>> filasDetG3;
    private List<List<Columna>> filasDetG4;
    private LineaNegocio lineaNegocioSeleccionada;
    private UnidadNegocio unidadNegocioSeleccionada;
    private String unidadNegocioNombre;
    private List<Mes> listadoMeses;
    private Integer anioInicio;
    private Integer mesInicio;
    private boolean showDetailLinea = false;
    private boolean showLineasOptions = false;
    private boolean showUnidadesOptions = false;
    private boolean showResumenPaises = true;
    private boolean showResumenUnidad = false;
    private List<Cliente8020Fc> clientes8020 = new LinkedList();
    private List<ClienteProvisionCuentas> cuentasIncobrables = new LinkedList<>();
    private Integer opcionButtonMenu = 1;
    private List<Columna> detailColumnSelected;
    private boolean showPopUpDialog;
    private boolean exportToPDF = false;
    private boolean exportToPDFRepVentas = false;
    private String popUpDialogPage;
    private Integer opcionTabGeneral;
    private StreamedContent content1;
    private StreamedContent content2;
    private StreamedContent content3;
    private StreamedContent content4;

    public void doExportToPDF() {
        setExportToPDF(true);
        Thread t = new Thread(new PdfResetThread());
        t.start();
    }

    public void doExportToPDFRepVentas() {
        setExportToPDFRepVentas(true);
        Thread t = new Thread(new PdfResetThread());
        t.start();
    }

    public boolean isExportToPDFRepVentas() {
        return exportToPDFRepVentas;
    }

    public void setExportToPDFRepVentas(boolean exportToPDFRepVentas) {
        this.exportToPDFRepVentas = exportToPDFRepVentas;
    }

    public boolean isExportToPDF() {
        return exportToPDF;
    }

    public void setExportToPDF(boolean exportToPDF) {
        this.exportToPDF = exportToPDF;
    }

    public StreamedContent getContent1() {
        downloadUnidades();
        return content1;
    }

    public void setContent1(StreamedContent content1) {
        this.content1 = content1;
    }

    public StreamedContent getContent2() {
        downloadDetalleUnidad();
        return content2;
    }

    public void setContent2(StreamedContent content2) {
        this.content2 = content2;
    }

    public StreamedContent getContent3() {
        downloadDetalleLinea();
        return content3;
    }

    public void setContent3(StreamedContent content3) {
        this.content3 = content3;
    }

    public StreamedContent getContent4() {
        downloadDetalleAgentes();
        return content4;
    }

    public void setContent4(StreamedContent content4) {
        this.content4 = content4;
    }

    public Integer getOpcionTabGeneral() {
        return opcionTabGeneral;
    }

    public void setOpcionTabGeneral(Integer opcionTabGeneral) {
        this.opcionTabGeneral = opcionTabGeneral;
    }

    public List<Columna> getColumnasRepVentas() {
        return columnasRepVentas;
    }

    public void setColumnasRepVentas(List<Columna> columnasRepVentas) {
        this.columnasRepVentas = columnasRepVentas;
    }

    public List<List<Columna>> getFilasRepVentas() {
        return filasRepVentas;
    }

    public void setFilasRepVentas(List<List<Columna>> filasRepVentas) {
        this.filasRepVentas = filasRepVentas;
    }

    public List<List<Columna>> getFilasRepVentasG1() {
        return filasRepVentasG1;
    }

    public void setFilasRepVentasG1(List<List<Columna>> filasRepVentasG1) {
        this.filasRepVentasG1 = filasRepVentasG1;
    }

    public List<List<Columna>> getFilasRepVentasG2() {
        return filasRepVentasG2;
    }

    public void setFilasRepVentasG2(List<List<Columna>> filasRepVentasG2) {
        this.filasRepVentasG2 = filasRepVentasG2;
    }

    public boolean isShowResumenPaises() {
        return showResumenPaises;
    }

    public void setShowResumenPaises(boolean showResumenPaises) {
        this.showResumenPaises = showResumenPaises;
    }

    public boolean isShowResumenUnidad() {
        return showResumenUnidad;
    }

    public void setShowResumenUnidad(boolean showResumenUnidad) {
        this.showResumenUnidad = showResumenUnidad;
    }

    public List<Columna> getColumnasPaises() {
        return columnasPaises;
    }

    public boolean isShowUnidadesOptions() {
        return showUnidadesOptions;
    }

    public void setShowUnidadesOptions(boolean showUnidadesOptions) {
        this.showUnidadesOptions = showUnidadesOptions;
    }

    public void setColumnasPaises(List<Columna> columnasPaises) {
        this.columnasPaises = columnasPaises;
    }

    public List<List<Columna>> getFilasPaises() {
        return filasPaises;
    }

    public void setFilasPaises(List<List<Columna>> filasPaises) {
        this.filasPaises = filasPaises;
    }

    public List<List<Columna>> getFilasPaisesG1() {
        return filasPaisesG1;
    }

    public void setFilasPaisesG1(List<List<Columna>> filasPaisesG1) {
        this.filasPaisesG1 = filasPaisesG1;
    }

    public List<List<Columna>> getFilasPaisesG2() {
        return filasPaisesG2;
    }

    public void setFilasPaisesG2(List<List<Columna>> filasPaisesG2) {
        this.filasPaisesG2 = filasPaisesG2;
    }

    public List<List<Columna>> getFilasPaisesG3() {
        return filasPaisesG3;
    }

    public void setFilasPaisesG3(List<List<Columna>> filasPaisesG3) {
        this.filasPaisesG3 = filasPaisesG3;
    }

    public List<List<Columna>> getFilasPaisesG4() {
        return filasPaisesG4;
    }

    public void setFilasPaisesG4(List<List<Columna>> filasPaisesG4) {
        this.filasPaisesG4 = filasPaisesG4;
    }

    public String getPopUpDialogPage() {
        return popUpDialogPage;
    }

    public void setPopUpDialogPage(String popUpDialogPage) {
        this.popUpDialogPage = popUpDialogPage;
    }

    public boolean isShowPopUpDialog() {
        return showPopUpDialog;
    }

    public void setShowPopUpDialog(boolean showPopUpDialog) {
        this.showPopUpDialog = showPopUpDialog;
    }

    public List<Columna> getDetailColumnSelected() {
        return detailColumnSelected;
    }

    public void setDetailColumnSelected(List<Columna> detailColumnSelected) {
        this.detailColumnSelected = detailColumnSelected;
    }

    public List<List<Columna>> getFilasDetG1() {
        return filasDetG1;
    }

    public void downloadUnidades() {
        Map<Integer, List<List<Columna>>> rows = new LinkedHashMap<>();
        rows.put(1, filasPaisesG1);
        rows.put(4, filasPaisesG4);
        ByteArrayOutputStream o = (ByteArrayOutputStream) ExcelProccesor.writeXlsFile(rows, columnasPaises);
        ByteArrayInputStream in = new ByteArrayInputStream(o.toByteArray());
        content1 = new DefaultStreamedContent(in, "application/vnd.ms-excel", "gridunidades.xls");
    }

    public void downloadDetalleUnidad() {
        Map<Integer, List<List<Columna>>> rows = new LinkedHashMap<>();
        rows.put(1, filasG1);
        rows.put(2, filasG2);
        rows.put(3, filasG3);
        rows.put(4, filasG4);
        ByteArrayOutputStream o = (ByteArrayOutputStream) ExcelProccesor.writeXlsFile(rows, columnas);
        ByteArrayInputStream in = new ByteArrayInputStream(o.toByteArray());
        content2 = new DefaultStreamedContent(in, "application/vnd.ms-excel", "griddetalleunidad.xls");
    }

    public void downloadDetalleLinea() {
        Map<Integer, List<List<Columna>>> rows = new LinkedHashMap<>();
        rows.put(1, filasDetG1);
        rows.put(2, filasDetG2);
        rows.put(3, filasDetG3);
        rows.put(4, filasDetG4);
        ByteArrayOutputStream o = (ByteArrayOutputStream) ExcelProccesor.writeXlsFile(rows, columnasDet);
        ByteArrayInputStream in = new ByteArrayInputStream(o.toByteArray());
        content3 = new DefaultStreamedContent(in, "application/vnd.ms-excel", "griddetallelinea.xls");
    }

    public void downloadDetalleAgentes() {
        Map<Integer, List<List<Columna>>> rows = new LinkedHashMap<>();
        rows.put(1, filasRepVentasG1);
        rows.put(4, filasRepVentasG2);
        ByteArrayOutputStream o = (ByteArrayOutputStream) ExcelProccesor.writeXlsFile(rows, columnasRepVentas);
        ByteArrayInputStream in = new ByteArrayInputStream(o.toByteArray());
        content4 = new DefaultStreamedContent(in, "application/vnd.ms-excel", "griddetallerepventas.xls");
    }

    public void detailSelectAction() {
        if (detailColumnSelected.get(0).getRubro().getPopup() != null
                && !detailColumnSelected.get(0).getRubro().getPopup().isEmpty()) {
            MICreditPopUpReport rep = BeanHelper.findBean(detailColumnSelected.get(0).getRubro().getPopup());
            rep.update(detailColumnSelected.get(detailColumnSelected.size() - 1).getDetail());
            setPopUpDialogPage(rep.getPage());
            setShowPopUpDialog(true);
        } else {
            setPopUpDialogPage("module/popups/empty.xhtml");
            setShowPopUpDialog(false);
        }
    }

    public void setFilasDetG1(List<List<Columna>> filasDetG1) {
        this.filasDetG1 = filasDetG1;
    }

    public List<List<Columna>> getFilasDetG2() {
        return filasDetG2;
    }

    public void setFilasDetG2(List<List<Columna>> filasDetG2) {
        this.filasDetG2 = filasDetG2;
    }

    public List<List<Columna>> getFilasDetG3() {
        return filasDetG3;
    }

    public void setFilasDetG3(List<List<Columna>> filasDetG3) {
        this.filasDetG3 = filasDetG3;
    }

    public List<List<Columna>> getFilasDetG4() {
        return filasDetG4;
    }

    public void setFilasDetG4(List<List<Columna>> filasDetG4) {
        this.filasDetG4 = filasDetG4;
    }

    public List<List<Columna>> getFilasG1() {
        return filasG1;
    }

    public void setFilasG1(List<List<Columna>> filasG1) {
        this.filasG1 = filasG1;
    }

    public List<List<Columna>> getFilasG2() {
        return filasG2;
    }

    public void setFilasG2(List<List<Columna>> filasG2) {
        this.filasG2 = filasG2;
    }

    public List<List<Columna>> getFilasG3() {
        return filasG3;
    }

    public void setFilasG3(List<List<Columna>> filasG3) {
        this.filasG3 = filasG3;
    }

    public List<List<Columna>> getFilasG4() {
        return filasG4;
    }

    public void setFilasG4(List<List<Columna>> filasG4) {
        this.filasG4 = filasG4;
    }

    public List<ClienteProvisionCuentas> getCuentasIncobrables() {
        if (cuentasIncobrables.isEmpty()) {
            try {
                cuentasIncobrables = reporteDao.getProvisionCuentas(anioInicio, mesInicio, lineaNegocioSeleccionada.getId(), unidadNegocioSeleccionada.getId());
            }
            catch (EaError ex) {
                log.error(ex);
                ex.printStackTrace(System.err);
            }
            catch (Exception ex) {
                log.error(ex);
            }
        }
        return cuentasIncobrables;
    }

    public void setCuentasIncobrables(List<ClienteProvisionCuentas> cuentasIncobrables) {
        this.cuentasIncobrables = cuentasIncobrables;
    }

    public Integer getOpcionButtonMenu() {
        return opcionButtonMenu;
    }

    public void setOpcionButtonMenu(Integer opcionButtonMenu) {
        this.opcionButtonMenu = opcionButtonMenu;
    }

    public List<Cliente8020Fc> getClientes8020() {
        if (clientes8020.isEmpty()) {
            try {
                clientes8020 = reporteDao.getClientes8020(anioInicio, mesInicio, lineaNegocioSeleccionada.getId(), unidadNegocioSeleccionada.getId());
            }
            catch (EaError | Exception ex) {
                log.error(ex);
            }
        }

        return clientes8020;
    }

    public void setClientes8020(List<Cliente8020Fc> clientes8020) {
        this.clientes8020 = clientes8020;
    }

    public boolean isShowLineasOptions() {
        return showLineasOptions;
    }

    public void setShowLineasOptions(boolean showLineasOptions) {
        this.showLineasOptions = showLineasOptions;
    }

    public boolean isShowDetailLinea() {
        return showDetailLinea;
    }

    public void setShowDetailLinea(boolean showDetailLinea) {
        this.showDetailLinea = showDetailLinea;
    }

    public MbSummary() {
        this.anioInicio = Calendar.getInstance().get(Calendar.YEAR);
    }

    private List<UnidadNegocio> getUnidadesDeNegocioConRuta() {
        if (unidadesDeNegocio == null || unidadesDeNegocio.isEmpty()) {
            //List<UnidadNegocio> listadoUnidadesNegocio = catalogosDao.getAllUnidadesNegocio();
            //List<UnidadNegocio> listadoUnidadesNegocio = catalogosDao.getAllVisibleUnidadesNegocio();
            List<UnidadNegocio> listadoUnidadesNegocio = usuarioApp.getPd().getUnidades();
            for (Iterator<UnidadNegocio> it = listadoUnidadesNegocio.iterator(); it.hasNext();) {
                UnidadNegocio unidadNegocio = it.next();
                if (unidadNegocio.getVisible()) {
                    unidadNegocio.setRutaImagen("images:" + unidadNegocio.getNombreImagen());
                } else {
                    it.remove();
                }
            }
            unidadesDeNegocio = listadoUnidadesNegocio;
        }
        return unidadesDeNegocio;
    }

    public void procesarFiltroResumenPaises() {
        cargarGridPaises();
        goResumenPaises();
    }

    public void goResumenPaises() {
        setShowUnidadesOptions(true);
        setShowResumenPaises(true);
        setShowResumenUnidad(false);
        setShowLineasOptions(false);
        setShowDetailLinea(false);
    }

    public void goResumenUnidadNegocio() {
        setShowUnidadesOptions(false);
        setShowResumenPaises(false);
        setShowResumenUnidad(true);
        setShowLineasOptions(true);
        setShowDetailLinea(false);
    }

    public void goResumenLineaNegocio() {
        setShowUnidadesOptions(false);
        setShowResumenPaises(false);
        setShowResumenUnidad(false);
        setShowLineasOptions(true);
        setShowDetailLinea(true);
    }

    public String doActionBackUnidades() {
        goResumenPaises();
        mbIndex.loadPage("micreditunidades.xhtml");
        return "unidades";
    }

    public String doActionBackDetalleUnidadNegocio() {
        goResumenUnidadNegocio();
        mbIndex.loadPage("micreditdetalleunidad.xhtml");
        return "detalleunidad";
    }

    public String doActionCargarDetalleLineaNegocio(LineaNegocio lineaNegocio) {
        cargarDetalleLineaNegocio(lineaNegocio);
        mbIndex.loadPage("micreditdetallelinea.xhtml");
        return "detallelinea";
    }

    public String doActionCargarDetalleUnidadNegocio(UnidadNegocio unidadNego) {
        cargarDetalleUnidadNegocio(unidadNego);
        mbIndex.loadPage("micreditdetalleunidad.xhtml");
        return "detalleunidad";
    }

    public void cargarDetalleUnidadNegocio(UnidadNegocio unidadNegocio) {
        setUnidadNegocioSeleccionada(unidadNegocio);
        cargarGridPrincipal();
        goResumenUnidadNegocio();
    }

    public void cargarDetalleLineaNegocio(LineaNegocio lineaNegocio) {
        setOpcionTabGeneral(0);
        setLineaNegocioSeleccionada(lineaNegocio);
        cargarGridPorLinea();
        cargarGridAgentes();
        goResumenLineaNegocio();
    }

    public void procesarFiltroDetail() {
        cargarGridPorLinea();
    }

    private List<LineaNegocio> getLineasDeNegocio() {
        if (this.lineasDeNegocios == null || this.lineasDeNegocios.isEmpty()) {
            //this.lineasDeNegocios = catalogosDao.getAllVisibleLineasNegocio();
            this.lineasDeNegocios = this.usuarioApp.getPd().getLineas();
            for (Iterator<LineaNegocio> it = this.lineasDeNegocios.iterator(); it.hasNext();) {
                LineaNegocio ln = it.next();
                if (!ln.getVisible()) {
                    it.remove();
                }
            }
        }
        return this.lineasDeNegocios;
    }

    /**
     * Llena detalle por pais
     */
    private void cargarGridPaises() {
        if ((this.anioInicio != null) && (this.mesInicio != null)) {
            List<Columna> gridHead = new LinkedList<>();
            List<Columna> gridRowModel = new LinkedList<>();
            List<List<Columna>> gridRows = new LinkedList<>();
            Map<Integer, UnidadNegocio> mapUnidades = new LinkedHashMap<>();
            gridHead.add(new Columna("Rubro", "0", gridHead.size()));
            gridRowModel.add(new Columna("", "0", gridRowModel.size()));
            for (UnidadNegocio ln : unidadesDeNegocio) {
                if (!mapUnidades.containsKey(ln.getId())) {
                    gridRowModel.add(new Columna("", "0.0", gridRowModel.size()));
                    gridHead.add(new Columna(ln.getNombre(), "0", gridHead.size()));
                    mapUnidades.put(ln.getId(), ln);
                }
            }
            gridHead.add(new Columna("Total", "0", gridHead.size()));
            gridRowModel.add(new Columna("", "0", gridRowModel.size()));
            try {
                List<MICredRubro> rubros = reporteDao.getRubrosPaisesMICredit();
                List<MICreditRowDetail> rowsGen = new LinkedList<>();
                List<MICreditRowDetail> rows = reporteDao.getMICreditGridPaisesRows(mesInicio, anioInicio, usuarioApp.getPd().getId());
                Map<String, List<Columna>> mapRows = new LinkedHashMap<>();
                for (MICredRubro rb : rubros) { //llena rubros
                    List<Columna> rubroRow = new LinkedList<>(gridRowModel);
                    Columna cRubro = new Columna(rb.getRubro(), rb.getRubro(), 0);
                    cRubro.setRubro(rb);
                    cRubro.setGrid(rb.getGrid());
                    rubroRow.set(0, cRubro);
                    mapRows.put(rb.getRubro(), rubroRow);
                }
                NumberFormat nf = NumberFormat.getInstance();
                nf.setMaximumFractionDigits(0);
                for (MICreditRowDetail r : rows) { //llena filas por rubro
                    try {
                        if (mapUnidades.containsKey(r.getUnidadNegocio())) {
                            Columna c = new Columna(mapUnidades.get(r.getUnidadNegocio()).getNombre(), r.getValor(), 0);
                            int indexOnRow = gridHead.indexOf(c);
                            c.setIndex(indexOnRow);
                            log.info(indexOnRow + " - " + r.getRubro());
                            if (mapRows.get(r.getRubro().trim()) != null) {
                                List<Columna> l = mapRows.get(r.getRubro().trim());
                                c.setGrid(l.get(0).getGrid());
                                c.setRubro(l.get(0).getRubro());
                                l.set(indexOnRow, c);

                                Columna totalCol = l.get(l.size() - 1);
                                try {
                                    if (c.getRubro().getSumarhor().equals("1")) {
                                        String totvalor = totalCol.getValor();
                                        if (totvalor.contains("%")) {
                                            totvalor = totvalor.substring(0, totvalor.indexOf("%"));
                                        }
                                        Float suma = nf.parse(totvalor).floatValue()
                                                + nf.parse(r.getValor().toString()).floatValue();

                                        totvalor = nf.format(suma);
                                        l.set(l.size() - 1, new Columna("", totvalor, l.size() - 1));
                                    }
                                }
                                catch (ParseException | NumberFormatException e) {
                                    System.out.println("no aplica para el formato de la fila!" + e.getMessage());
                                }
                            }
                        } else {
                            rowsGen.add(r);
                        }
                    }
                    catch (Exception e) {
                        e.printStackTrace(System.err);
                    }
                }
                for (MICreditRowDetail rw : rowsGen) {
                    if (mapRows.containsKey(rw.getRubro().substring(4))) {
                        Columna col = new Columna("", rw.getValor(), 10);
                        List<Columna> grdRow = mapRows.get(rw.getRubro().substring(4));
                        grdRow.set(grdRow.size() - 1, col);
                    }
                }
                for (Map.Entry<String, List<Columna>> e : mapRows.entrySet()) {
                    gridRows.add(e.getValue());
                }
                setFilasPaises(gridRows);
                setColumnasPaises(gridHead);
                setFilasPaisesG1(getFilasByGrid(1, getFilasPaises()));
                for (List<Columna> row : getFilasPaisesG1()) {
                    if (row.get(0).getHeader().equals("% en Overdue (del total de exposicion)")) {
                        row.get(row.size() - 1).setValor(row.get(row.size() - 1).getValor() + " %");
                    }
                    if (row.get(0).getHeader().equals("YTD OverDue")) {
                        row.get(row.size() - 1).setValor(row.get(row.size() - 1).getValor() + " %");
                    }
                }
                setFilasPaisesG2(getFilasByGrid(2, getFilasPaises()));
                setFilasPaisesG3(getFilasByGrid(3, getFilasPaises()));
                setFilasPaisesG4(getFilasByGrid(4, getFilasPaises()));
            }
            catch (EaError ex) {
                log.error("Error obteniendo los datos de grid principal!", ex);
            }
        }
    }

    /**
     * Llena detalle por pais
     */
    private void cargarGridPrincipal() {
        if ((this.unidadNegocioSeleccionada != null) && (this.mesInicio != null)) {
            List<Columna> gridHead = new LinkedList<>();
            List<Columna> gridRowModel = new LinkedList<>();
            List<List<Columna>> gridRows = new LinkedList<>();
            Map<Integer, LineaNegocio> mapLineas = new LinkedHashMap<>();
            gridHead.add(new Columna("Rubro", "0", gridHead.size()));
            gridRowModel.add(new Columna("", "0", gridRowModel.size()));
            for (LineaNegocio ln : getLineasDeNegocio()) {
                gridRowModel.add(new Columna("", "0.0", gridRowModel.size()));
                gridHead.add(new Columna(ln.getNombre(), "0", gridHead.size()));
                mapLineas.put(ln.getId(), ln);
            }
            gridHead.add(new Columna("Total", "0", gridHead.size()));
            gridRowModel.add(new Columna("", "0", gridRowModel.size()));
            try {
                List<MICredRubro> rubros = reporteDao.getRubrosMICredit();
                List<MICreditRowDetail> rows = reporteDao.getMICreditGridRows(mesInicio, anioInicio, unidadNegocioSeleccionada.getId(), 0, usuarioApp.getPd().getId());
                List<MICreditRowDetail> rowsTotalPais = new LinkedList<>();
                Map<String, List<Columna>> mapRows = new LinkedHashMap<>();
                for (MICredRubro rb : rubros) { //llena rubros
                    List<Columna> rubroRow = new LinkedList<>(gridRowModel);
                    Columna cRubro = new Columna(rb.getRubro(), rb.getRubro(), 0);
                    cRubro.setRubro(rb);
                    cRubro.setGrid(rb.getGrid());
                    rubroRow.set(0, cRubro);
                    mapRows.put(rb.getRubro(), rubroRow);
                }
                for (MICreditRowDetail r : rows) { //llena filas por rubro
                    try {
                        if (mapLineas.containsKey(r.getLineaNegocio())) { //para evitar que de nullpointer por lineas omitidas
                            Columna c = new Columna(mapLineas.get(r.getLineaNegocio()).getNombre(), r.getValor(), 0);
                            int indexOnRow = gridHead.indexOf(c);
                            c.setIndex(indexOnRow);
                            log.info(indexOnRow + " - " + r.getRubro());
                            if (mapRows.get(r.getRubro().trim()) != null) {
                                List<Columna> l = mapRows.get(r.getRubro().trim());
                                c.setGrid(l.get(0).getGrid());
                                c.setRubro(l.get(0).getRubro());
                                l.set(indexOnRow, c);

                                Columna totalCol = l.get(l.size() - 1);
                                try {
                                    if (c.getRubro().getSumarhor().equals("1")) {
                                        NumberFormat nf = NumberFormat.getInstance();
                                        nf.setMaximumFractionDigits(0);
                                        Float suma = nf.parse(totalCol.getValor()).floatValue()
                                                + nf.parse(r.getValor().toString()).floatValue();
                                        l.set(l.size() - 1, new Columna("", nf.format(suma), l.size() - 1));
                                    }
                                }
                                catch (ParseException | NumberFormatException e) {
                                    System.out.println("no aplica para el formato de la fila!" + e.getMessage());
                                }
                            }
                        } else if (r.getLineaNegocio().equals(0)) { //valores totales de pais
                            rowsTotalPais.add(r);
                        }
                    }
                    catch (Exception e) {
                        e.printStackTrace(System.err);
                    }
                }
                for (MICreditRowDetail rw : rowsTotalPais) {
                    Columna col = new Columna("", rw.getValor(), 10);
                    List<Columna> grdRow = mapRows.get(rw.getRubro());
                    grdRow.set(grdRow.size() - 1, col);
                }
                for (Map.Entry<String, List<Columna>> e : mapRows.entrySet()) {
                    gridRows.add(e.getValue());
                }
                setFilas(gridRows);
                setColumnas(gridHead);
                setFilasG1(getFilasByGrid(1, filas));
                for (List<Columna> row : getFilasG1()) {
                    if (row.get(0).getHeader().equals("% en Overdue (del total de exposicion)")) {
                        row.get(row.size() - 1).setValor(row.get(row.size() - 1).getValor() + " %");
                    }
                    if (row.get(0).getHeader().equals("YTD OverDue")) {
                        row.get(row.size() - 1).setValor(row.get(row.size() - 1).getValor() + " %");
                    }
                }
                setFilasG2(getFilasByGrid(2, filas));
                setFilasG3(getFilasByGrid(3, filas));
                setFilasG4(getFilasByGrid(4, filas));
            }
            catch (EaError ex) {
                log.error("Error obteniendo los datos de grid principal!", ex);
            }
        }
    }

    private void cargarGridAgentes() {
        if (this.unidadNegocioSeleccionada != null && this.mesInicio != null && lineaNegocioSeleccionada != null) {
            try {
                List<Columna> gridHead = new LinkedList<>();
                List<Columna> gridColsModel = new LinkedList<>();
                List<List<Columna>> gridRows = new LinkedList<>();
                Map<String, List<Columna>> mapRows = new LinkedHashMap<>();

                gridHead.add(new Columna("Rubro", "0", gridHead.size()));
                gridColsModel.add(new Columna("", "0", gridColsModel.size()));
                List<RepresentanteVentas> repventas = reporteDao.getRepresentantesVentas(mesInicio, anioInicio, unidadNegocioSeleccionada.getId(),
                        lineaNegocioSeleccionada.getId());
                for (int j = 0; j < repventas.size(); j++) {
                    gridColsModel.add(new Columna("", "0.0", gridColsModel.size()));
                    gridHead.add(new Columna(repventas.get(j).getRepventas(), "0", gridHead.size()));
                }
                List<MICredRubro> rubros = reporteDao.getRubrosRepVentasMICredit();
                for (MICredRubro rb : rubros) { //llena rubros
                    List<Columna> rubroRow = new LinkedList<>(gridColsModel);
                    Columna cRubro = new Columna(rb.getRubro().trim(), rb.getRubro(), 0);
                    cRubro.setGrid(rb.getGrid());
                    cRubro.setRubro(rb);
                    rubroRow.set(0, cRubro);
                    mapRows.put(rb.getRubro(), rubroRow);
                }
                List<MICreditRowDetail> rows = reporteDao.getMICreditRepVentasGridRows(mesInicio, anioInicio, unidadNegocioSeleccionada.getId(), lineaNegocioSeleccionada.getId());
                for (MICreditRowDetail r : rows) { //llena filas por rubro
                    Columna c = new Columna(r.getRepventas(), r.getValor(), 0);
                    int indexOnRow = gridHead.indexOf(c);
                    if (indexOnRow >= 0) {
                        c.setIndex(indexOnRow);
                        r.setMes(mesInicio);
                        r.setAnio(anioInicio);
                        if (mapRows.get(r.getRubro().trim()) != null) {
                            List<Columna> l = mapRows.get(r.getRubro().trim());
                            c.setGrid(l.get(0).getGrid());
                            c.setRubro(l.get(0).getRubro());
                            c.setDetail(r);
                            if (l.get(0).getDetail() == null) {
                                l.get(0).setDetail(r);
                            }
                            l.set(indexOnRow, c);
                        }
                    }
                }
                for (Map.Entry<String, List<Columna>> e : mapRows.entrySet()) {
                    gridRows.add(e.getValue());
                }
                setFilasRepVentas(gridRows);
                setColumnasRepVentas(gridHead);
                setFilasRepVentasG1(getFilasByGrid(1, gridRows));
                setFilasRepVentasG2(getFilasByGrid(4, gridRows));
            }
            catch (EaError ex) {
                log.error("Error obteniendo los datos de grid principal!", ex);
            }
        }
    }

    private void cargarGridPorLinea() {
        if ((this.unidadNegocioSeleccionada != null) && (this.mesInicio != null)) {
            try {
                List<Columna> gridHead = new LinkedList<>();
                List<Columna> gridColsModel = new LinkedList<>();
                List<List<Columna>> gridRows = new LinkedList<>();
                Map<String, List<Columna>> mapRows = new LinkedHashMap<>();
                setClientes8020(new LinkedList<Cliente8020Fc>());
                setCuentasIncobrables(new LinkedList<ClienteProvisionCuentas>());
                gridHead.add(new Columna("Rubro", "0", gridHead.size()));
                gridColsModel.add(new Columna("", "0", gridColsModel.size()));

                for (int j = 0; j <= mesInicio; j++) {
                    gridColsModel.add(new Columna("", "0.0", gridColsModel.size()));
                    gridHead.add(new Columna(listadoMeses.get(j).getNombreMes(), "0", gridHead.size()));
                }
                List<MICredRubro> rubros = reporteDao.getRubrosMICredit();
                for (MICredRubro rb : rubros) { //llena rubros
                    List<Columna> rubroRow = new LinkedList<>(gridColsModel);
                    Columna cRubro = new Columna(rb.getRubro().trim(), rb.getRubro(), 0);
                    cRubro.setGrid(rb.getGrid());
                    cRubro.setRubro(rb);
                    rubroRow.set(0, cRubro);
                    mapRows.put(rb.getRubro(), rubroRow);
                }
                for (int j = 0; j <= mesInicio; j++) {
                    List<MICreditRowDetail> rows = reporteDao.getMICreditGridRows(j, anioInicio, unidadNegocioSeleccionada.getId(), lineaNegocioSeleccionada.getId(), usuarioApp.getPd().getId());
                    for (MICreditRowDetail r : rows) { //llena filas por rubro
                        Columna c = new Columna(listadoMeses.get(j).getNombreMes(), r.getValor(), 0);
                        int indexOnRow = gridHead.indexOf(c);
                        c.setIndex(indexOnRow);
                        r.setMes(j);
                        r.setAnio(anioInicio);
                        if (mapRows.get(r.getRubro().trim()) != null) {
                            List<Columna> l = mapRows.get(r.getRubro().trim());
                            c.setGrid(l.get(0).getGrid());
                            c.setRubro(l.get(0).getRubro());
                            c.setDetail(r);
                            if (l.get(0).getDetail() == null) {
                                l.get(0).setDetail(r);
                            }
                            l.set(indexOnRow, c);
                        }
                    }
                }
                for (Map.Entry<String, List<Columna>> e : mapRows.entrySet()) {
                    gridRows.add(e.getValue());
                }
                setFilasDet(gridRows);
                setColumnasDet(gridHead);
                setFilasDetG1(getFilasByGrid(1, filasDet));
                setFilasDetG2(getFilasByGrid(2, filasDet));
                setFilasDetG3(getFilasByGrid(3, filasDet));
                setFilasDetG4(getFilasByGrid(4, filasDet));
            }
            catch (EaError ex) {
                log.error("Error obteniendo los datos de grid principal!", ex);
            }
        }
    }

    /**
     * Genera graficas para la pagina
     */
    public void prepareGraphics() {
        prepareVentasExposGraph();
        prepareExposOverdueGraph();
        prepareOverDueYTDTargGraph();
        prepareDSOYTDTargetGraph();
        prepareIntCarteraAntiguedadPorMes(mesInicio.intValue() > 0 ? (mesInicio.intValue() - 1) : 0, false);
        prepareIntCarteraAntiguedadPorMes(mesInicio.intValue(), true);
        prepareOrdenesRet();
        prepareMotivosRetencionOrdenes();
        prepareChequesRechazados();
    }

    private void prepareVentasExposGraph() {
        NumberFormat nf = new DecimalFormat();
        int ventasRowNum = 0;
        int exposiRowNum = 1;
        List<Float> valsVentas = new LinkedList<>();
        List<Float> valsExposi = new LinkedList<>();
        List<String> meses = new LinkedList<>();
        List<Columna> ventasRow = filasDetG1.get(ventasRowNum);
        List<Columna> exposiRow = filasDetG1.get(exposiRowNum);
        for (int j = 0; j <= mesInicio; j++) {
            try {
                valsVentas.add(new Float(nf.parse(ventasRow.get(j + 1).getValor()).floatValue()).floatValue() / 1000);
                valsExposi.add(new Float(nf.parse(exposiRow.get(j + 1).getValor()).floatValue()).floatValue() / 1000);
                meses.add(listadoMeses.get(j).getNombreMes().substring(0, 3));
            }
            catch (ParseException ex) {
                log.error(ex);
            }
        }

        for (int j = mesInicio + 1; j < 12; j++) {
            valsVentas.add(BigDecimal.ZERO.floatValue());
            valsExposi.add(BigDecimal.ZERO.floatValue());
            meses.add(listadoMeses.get(j).getNombreMes().substring(0, 3));
        }
        graficasUnopetrol.ventasExposicion(valsVentas, valsExposi, meses,
                "Ventas", "Exposicion");
    }

    private void prepareExposOverdueGraph() {
        NumberFormat nf = new DecimalFormat();
        int overdueRowNum = 3;
        int exposiRowNum = 1;
        List<Float> valsOverDue = new LinkedList<>();
        List<Float> valsExposi = new LinkedList<>();
        List<String> meses = new LinkedList<>();
        List<Columna> overdueRow = filasDetG1.get(overdueRowNum);
        List<Columna> exposiRow = filasDetG1.get(exposiRowNum);
        for (int j = 0; j <= mesInicio; j++) {
            try {
                valsOverDue.add(new Float(nf.parse(overdueRow.get(j + 1).getValor()).floatValue() / 1000));
                valsExposi.add(new Float(nf.parse(exposiRow.get(j + 1).getValor()).floatValue() / 1000));
                meses.add(listadoMeses.get(j).getNombreMes().substring(0, 3));
            }
            catch (ParseException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        for (int j = mesInicio + 1; j < 12; j++) {
            valsOverDue.add(BigDecimal.ZERO.floatValue());
            valsExposi.add(BigDecimal.ZERO.floatValue());
            meses.add(listadoMeses.get(j).getNombreMes().substring(0, 3));
        }
        graficasUnopetrol.exposicionOverdue(valsOverDue, valsExposi, meses,
                "OveDue", "Exposicion");
    }

    private void prepareOverDueYTDTargGraph() {
        NumberFormat nf = new DecimalFormat();
        int overdueRowNum = 4;
        int overdueYTDRowNum = 5;
        int overdueTargetRowNum = 6;

        List<Float> valsPorcOverdue = new LinkedList<>();
        List<Float> valsOverdueYTD = new LinkedList<>();
        List<Float> valsOverdueTar = new LinkedList<>();
        List<Columna> overdueRow = filasDetG1.get(overdueRowNum);
        List<Columna> overdueTargetRow = filasDetG1.get(overdueTargetRowNum);
        List<Columna> overdueYTDRow = filasDetG1.get(overdueYTDRowNum);
        for (int j = 0; j <= mesInicio; j++) {
            try {
                valsPorcOverdue.add(nf.parse(overdueRow.get(j + 1).getValor().replace('%', ' ').trim()).floatValue());
                valsOverdueYTD.add(nf.parse(overdueYTDRow.get(j + 1).getValor().replace('%', ' ').trim()).floatValue());
                valsOverdueTar.add(nf.parse(overdueTargetRow.get(j + 1).getValor().replace('%', ' ').trim()).floatValue());
            }
            catch (ParseException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        for (int j = mesInicio + 1; j < 12; j++) {
            valsPorcOverdue.add(BigDecimal.ZERO.floatValue());
            valsOverdueYTD.add(BigDecimal.ZERO.floatValue());
            valsOverdueTar.add(Float.valueOf(overdueTargetRow.get(mesInicio).getValor().replace('%', ' ').trim()));
        }
        graficasUnopetrol.overdueYTDTarger(valsPorcOverdue, valsOverdueYTD, valsOverdueTar, "prepare");
    }

    private void prepareDSOYTDTargetGraph() {
        NumberFormat nf = new DecimalFormat();
        int dsoRowNum = 7;
        int dsoYTDRowNum = 8;
        int dsoTargetRowNum = 9;

        List<Float> dsoVals = new LinkedList<>();
        List<Float> dsoytdvals = new LinkedList<>();
        List<Float> dsotargetvals = new LinkedList<>();
        List<Columna> overdueRow = filasDetG1.get(dsoRowNum);
        List<Columna> overdueTarRow = filasDetG1.get(dsoTargetRowNum);
        List<Columna> overdueYTDRow = filasDetG1.get(dsoYTDRowNum);
        int jfinal = 0;
        for (int j = 0; j <= mesInicio; j++) {
            try {
                dsoVals.add(nf.parse(overdueRow.get(j + 1).getValor()).floatValue());
                dsoytdvals.add(nf.parse(overdueYTDRow.get(j + 1).getValor()).floatValue());
                dsotargetvals.add(nf.parse(overdueTarRow.get(j + 1).getValor()).floatValue());
                jfinal = j;
            }
            catch (ParseException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        for (int j = mesInicio + 1; j < 12; j++) {
            dsoVals.add(BigDecimal.ZERO.floatValue());
            dsoytdvals.add(BigDecimal.ZERO.floatValue());
            dsotargetvals.add(Float.valueOf(overdueTarRow.get(mesInicio).getValor()));
        }
        graficasUnopetrol.dSOYTDTarget(dsoVals, dsoytdvals, dsotargetvals, "prepare");

    }

    private void prepareIntCarteraAntiguedadPorMes(Integer mes, boolean usarSigte) {
        try {
            NumberFormat nf = new DecimalFormat();
            List<Donut> valores = new LinkedList<>();
            int deudaNoVencida = 3;
            int deuda1a30 = 4;
            int deuda31a60 = 5;
            int deuda61a90 = 6;
            int deuda91a180 = 7;
            int deuda181mas = 8;
            double total = Math.ceil(nf.parse(filasDetG4.get(deudaNoVencida).get(mes + 1).getValor()).doubleValue())
                    + Math.ceil(nf.parse(filasDetG4.get(deuda1a30).get(mes + 1).getValor()).doubleValue() < 0 ? (nf.parse(filasDetG4.get(deuda1a30).get(mes + 1).getValor()).doubleValue() * (-1))
                    : nf.parse(filasDetG4.get(deuda1a30).get(mes + 1).getValor()).doubleValue())
                    + Math.ceil(nf.parse(filasDetG4.get(deuda31a60).get(mes + 1).getValor()).doubleValue() < 0 ? (nf.parse(filasDetG4.get(deuda31a60).get(mes + 1).getValor()).doubleValue() * (-1))
                    : nf.parse(filasDetG4.get(deuda31a60).get(mes + 1).getValor()).doubleValue())
                    + Math.ceil(nf.parse(filasDetG4.get(deuda61a90).get(mes + 1).getValor()).doubleValue() < 0 ? (nf.parse(filasDetG4.get(deuda61a90).get(mes + 1).getValor()).doubleValue() * (-1))
                    : nf.parse(filasDetG4.get(deuda61a90).get(mes + 1).getValor()).doubleValue())
                    + Math.ceil(nf.parse(filasDetG4.get(deuda91a180).get(mes + 1).getValor()).doubleValue() < 0 ? (nf.parse(filasDetG4.get(deuda91a180).get(mes + 1).getValor()).doubleValue() * (-1))
                    : nf.parse(filasDetG4.get(deuda91a180).get(mes + 1).getValor()).doubleValue())
                    + Math.ceil(nf.parse(filasDetG4.get(deuda181mas).get(mes + 1).getValor()).doubleValue() < 0 ? (nf.parse(filasDetG4.get(deuda181mas).get(mes + 1).getValor()).doubleValue() * (-1))
                    : nf.parse(filasDetG4.get(deuda181mas).get(mes + 1).getValor()).doubleValue());

            double ddeudaNoVencida = ((nf.parse(filasDetG4.get(deudaNoVencida).get(mes + 1).getValor()).doubleValue() / total) * 100);
            double ddeuda1a30 = ((nf.parse(filasDetG4.get(deuda1a30).get(mes + 1).getValor()).doubleValue() / total) * 100);
            double ddeuda31a60 = ((nf.parse(filasDetG4.get(deuda31a60).get(mes + 1).getValor()).doubleValue() / total) * 100);
            double ddeuda61a90 = ((nf.parse(filasDetG4.get(deuda61a90).get(mes + 1).getValor()).doubleValue() / total) * 100);
            double ddeuda91a180 = ((nf.parse(filasDetG4.get(deuda91a180).get(mes + 1).getValor()).doubleValue() / total) * 100);
            double ddeuda181mas = ((nf.parse(filasDetG4.get(deuda181mas).get(mes + 1).getValor()).doubleValue() / total) * 100);

            NumberFormat nb = NumberFormat.getInstance();
            nb.setMaximumFractionDigits(1);
            valores.add(new Donut("No Vencido", nb.format(Math.abs(ddeudaNoVencida))));
            valores.add(new Donut("1 a 30 dias", nb.format(Math.abs(ddeuda1a30))));
            valores.add(new Donut("31 a 60 dias", nb.format(Math.abs(ddeuda31a60))));
            valores.add(new Donut("61 a 90 dias", nb.format(Math.abs(ddeuda61a90))));
            valores.add(new Donut("91 a 180 dias", nb.format(Math.abs(ddeuda91a180))));
            valores.add(new Donut(">180 dias", nb.format(Math.abs(ddeuda181mas))));

            if (usarSigte) {
                graficasUnopetrol.integracionCarteraAntiguedadSigMes(valores);

            } else {
                graficasUnopetrol.integracionCarteraAntiguedad(valores);
            }
        }
        catch (ParseException ex) {
            log.error(ex);
        }
    }

    private void prepareOrdenesRet() {
        NumberFormat nf = new DecimalFormat();
        int ordenesRet = 1;
        int ordenesTot = 0;
        List<HistogramPoint> ordenesRetCant = new LinkedList<>();
        List<HistogramPoint> ordenesRetPorc = new LinkedList<>();
        List<Columna> ordenesRetRow = filasDetG2.get(ordenesRet);
        List<Columna> ordenesRow = filasDetG2.get(ordenesTot);
        int jfinal = 0;
        for (int j = 0; j <= mesInicio; j++) {
            try {
                HistogramPoint hpCantidad = new HistogramPoint();
                HistogramPoint hpPorc = new HistogramPoint();
                Float cantOrdRetenida = new Float(nf.parse(ordenesRetRow.get(j + 1).getValor()).floatValue());
                Float totOrdenes = new Float(nf.parse(ordenesRow.get(j + 1).getValor()).floatValue());
                hpCantidad.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
                hpCantidad.setValue((int) cantOrdRetenida.floatValue());
                hpPorc.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
                hpPorc.setValue((int) ((cantOrdRetenida.floatValue() / totOrdenes.floatValue()) * 100));
                ordenesRetCant.add(hpCantidad);
                ordenesRetPorc.add(hpPorc);
            }
            catch (ParseException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }
            jfinal = j;
        }



        for (int j = mesInicio + 1; j < 12; j++) {
            HistogramPoint hpCantidad = new HistogramPoint();
            HistogramPoint hpPorc = new HistogramPoint();

            hpCantidad.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
            hpCantidad.setValue(0);
            hpPorc.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
            hpPorc.setValue(0);

            ordenesRetCant.add(hpCantidad);
            ordenesRetPorc.add(hpPorc);
        }

        graficasUnopetrol.ordenesRetenidas(ordenesRetCant, ordenesRetPorc, "Cantidad Ordenes Retenidas", "% del Total de Ordenes");
    }

    private void prepareMotivosRetencionOrdenes() {
        NumberFormat nf = new DecimalFormat();
        int ordRetDeudaVenc = 3;
        int ordRetLimiteCred = 4;
        int ordRetLimitCredYDeudaVenc = 5;
        List<Integer> ordRetDeudaVencida = new LinkedList<>();
        List<Integer> ordRetLimiteCredito = new LinkedList<>();
        List<Integer> ordRetLimiteCredYDeudaVencid = new LinkedList<>();
        List<Columna> ordRetDeudaVencRow = filasDetG2.get(ordRetDeudaVenc);
        List<Columna> ordRetLimiteCredRow = filasDetG2.get(ordRetLimiteCred);
        List<Columna> ordRetLimiCredYDeudaRow = filasDetG2.get(ordRetLimitCredYDeudaVenc);
        int jfinal = 0;
        for (int j = 0; j <= mesInicio; j++) {
            try {
                ordRetDeudaVencida.add(nf.parse(ordRetDeudaVencRow.get(j + 1).getValor()).intValue());
                ordRetLimiteCredito.add(nf.parse(ordRetLimiteCredRow.get(j + 1).getValor()).intValue());
                ordRetLimiteCredYDeudaVencid.add(nf.parse(ordRetLimiCredYDeudaRow.get(j + 1).getValor()).intValue());
            }
            catch (ParseException ex) {
                log.error(ex);
            }
            jfinal = j;
        }


        for (int j = mesInicio + 1; j < 12; j++) {
            ordRetDeudaVencida.add(BigDecimal.ZERO.intValue());
            ordRetLimiteCredito.add(BigDecimal.ZERO.intValue());
            ordRetLimiteCredYDeudaVencid.add(BigDecimal.ZERO.intValue());
        }

        graficasUnopetrol.motivosRetencionOrdenes(ordRetDeudaVencida, ordRetLimiteCredito, ordRetLimiteCredYDeudaVencid,
                "Ret. Deuda Vencida", "Ret. Limite Credito", "Ret. Limite Credito & Deuda Vencida");
    }

    private void prepareChequesRechazados() {
        NumberFormat nf = new DecimalFormat();
        int chequesRecCa = 1;
        int chequesRecM = 0;
        List<HistogramPoint> cheqReCant = new LinkedList<>();
        List<HistogramPoint> cheqRePorc = new LinkedList<>();
        List<Columna> cheqRecRow = filasDetG3.get(chequesRecCa);
        List<Columna> cheqRecMRow = filasDetG3.get(chequesRecM);
        int jfinal = 0;
        for (int j = 0; j <= mesInicio; j++) {
            try {
                HistogramPoint hpCantidad = new HistogramPoint();
                HistogramPoint hpMonto = new HistogramPoint();
                Float cantiCheqRech = new Float(nf.parse(cheqRecRow.get(j + 1).getValor()).floatValue());
                Float montoCheqRech = new Float(nf.parse(cheqRecMRow.get(j + 1).getValor()).floatValue() / 1000);
                hpCantidad.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
                hpCantidad.setValue((int) cantiCheqRech.floatValue());
                hpMonto.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
                hpMonto.setValue((int) montoCheqRech.floatValue());
                cheqReCant.add(hpCantidad);
                cheqRePorc.add(hpMonto);
            }
            catch (ParseException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }
            jfinal = j;
        }


        for (int j = mesInicio + 1; j < 12; j++) {
            HistogramPoint hpCantidad = new HistogramPoint();
            HistogramPoint hpMonto = new HistogramPoint();

            hpCantidad.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
            hpCantidad.setValue(BigDecimal.ZERO.intValue());
            hpMonto.setName(listadoMeses.get(j).getNombreMes().substring(0, 3));
            hpMonto.setValue(BigDecimal.ZERO.intValue());

            cheqReCant.add(hpCantidad);
            cheqRePorc.add(hpMonto);
        }


        graficasUnopetrol.chequesRechazados(cheqReCant, cheqRePorc); //, "Cantidad Ordenes Retenidas", "% del Total de Ordenes");
    }

    public List<List<Columna>> getFilasByGrid(Integer grid, List<List<Columna>> filas) {
        List<List<Columna>> listadoFilas = new LinkedList<>();
        for (List<Columna> f : filas) {
            if (f.get(0).getGrid().equals(grid)) {
                listadoFilas.add(f);
            }
        }
        return listadoFilas;
    }

    public List<Mes> getListadoMeses() {
        if (this.listadoMeses == null || this.listadoMeses.isEmpty()) {
            this.listadoMeses = Tools.getMeses();
        }
        return listadoMeses;
    }

    public List<UnidadNegocio> getUnidadesDeNegocio() {
        this.unidadesDeNegocio = getUnidadesDeNegocioConRuta();
        return this.unidadesDeNegocio;
    }

    public void setUnidadesDeNegocio(List<UnidadNegocio> unidadesDeNegocio) {
        this.unidadesDeNegocio = unidadesDeNegocio;
    }

    public List<LineaNegocio> getLineasDeNegocios() {
        this.lineasDeNegocios = getLineasDeNegocio();
        return lineasDeNegocios;
    }

    public void setLineasDeNegocios(List<LineaNegocio> lineasDeNegocios) {
        this.lineasDeNegocios = lineasDeNegocios;
    }

    public List<Columna> getColumnas() {
        return columnas;
    }

    public void setColumnas(List<Columna> columnas) {
        this.columnas = columnas;
    }

    public void setListadoMeses(List<Mes> listadoMeses) {
        this.listadoMeses = listadoMeses;
    }

    public List<List<Columna>> getFilas() {
        return filas;
    }

    public void setFilas(List<List<Columna>> filas) {
        this.filas = filas;
    }

    public LineaNegocio getLineaNegocioPorId(int idLineaNegocio) {
        try {
            return reporteDao.obtenerLineaNegocio(idLineaNegocio);
        }
        catch (EaError ex) {
            log.error("Error obteniendo los datos de grid principal!", ex);
        }
        return new LineaNegocio();
    }

    public LineaNegocio getLineaNegocioSeleccionada() {
        return lineaNegocioSeleccionada;
    }

    public void setLineaNegocioSeleccionada(LineaNegocio lineaNegocioSeleccionada) {
        this.lineaNegocioSeleccionada = lineaNegocioSeleccionada;
    }

    public List<Columna> getColumnasDet() {
        return columnasDet;
    }

    public void setColumnasDet(List<Columna> columnasDet) {
        this.columnasDet = columnasDet;
    }

    public List<List<Columna>> getFilasDet() {
        return filasDet;
    }

    public void setFilasDet(List<List<Columna>> filasDet) {
        this.filasDet = filasDet;
    }

    public UnidadNegocio getUnidadNegocioSeleccionada() {
        return unidadNegocioSeleccionada;
    }

    public void setUnidadNegocioSeleccionada(UnidadNegocio unidadNegocioSeleccionada) {
        this.unidadNegocioSeleccionada = unidadNegocioSeleccionada;
    }

    public String getUnidadNegocioNombre() {
        return unidadNegocioNombre;
    }

    public void setUnidadNegocioNombre(String unidadNegocioNombre) {
        this.unidadNegocioNombre = unidadNegocioNombre;
    }

    public Integer getAnioInicio() {
        return anioInicio;
    }

    public void setAnioInicio(Integer anioInicio) {
        this.anioInicio = anioInicio;
    }

    public Integer getMesInicio() {
        if (mesInicio == null) {
            mesInicio = getListadoMeses().get(0).getNumeroMes();
        }
        return mesInicio;
    }

    public void setMesInicio(Integer mesInicio) {
        this.mesInicio = mesInicio;
    }

    private class PdfResetThread implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(5000);
                MbSummary.this.setExportToPDF(false);
                System.out.println("reset de PDF finalizado!");
            }
            catch (InterruptedException ex) {
                java.util.logging.Logger.getLogger(MbSummary.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }
}
